composite.h

Go to the documentation of this file.

// WOLF - Copyright (C) 2020-2026
// Institut de Robòtica i Informàtica Industrial, CSIC-UPC.
// Authors: Joan Solà Ortega (jsola@iri.upc.edu) and
// Joan Vallvé Navarro (jvallve@iri.upc.edu)
// All rights reserved.
//
// This file is part of WOLF: http://www.iri.upc.edu/wolf
// WOLF is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 3
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
 
#include "core/common/wolf.h"
#include <string>
#include <map>
#include <algorithm>
#include "yaml-cpp/yaml.h"
 
namespace wolf
{
using std::map;
 
typedef std::string StateKeys;
 
static std::string ALL_KEYS = " ";
 
StateKeys keysUnion(const StateKeys& _keys1, const StateKeys& _keys2);
 
StateKeys keysIntersection(const StateKeys& _keys1, const StateKeys& _keys2);
 
template <typename T>
class Composite : public map<char, T>
{
  public:
    using CompositeType = T;
 
    using map<char, T>::map;
    Composite(const YAML::Node&  _n,
              const std::string& _field,
              const bool         _required,
              const std::string& _keys = ALL_KEYS);
    virtual ~Composite() = default;
 
    bool      has(char _key) const;
    bool      has(const StateKeys& _structure) const;
    StateKeys getKeys() const;
 
    friend std::ostream& operator<<(std::ostream& _os, const Composite<T>& _x)
    {
        for (auto&& pair : _x)
        {
            _os << pair.first << ": " << pair.second << std::endl;
        }
        return _os;
    }
 
    Composite operator()(const std::string& _keys) const;
 
    YAML::Node toYaml() const;
};
 
typedef Composite<bool> BoolComposite;
 
template <typename T>
inline Composite<T>::Composite(const YAML::Node&  _n,
                               const std::string& _field,
                               const bool         _required,
                               const std::string& _keys)
{
    if (_n.IsDefined())
    {
        if (not _n.IsMap())
        {
            throw std::runtime_error("Composite: constructor with a non-map yaml node");
        }
 
        // check existence of _keys in node
        if (_keys != ALL_KEYS)
            for (auto key : _keys)
                if (not _n[key] and _required)
                {
                    throw std::runtime_error(std::string("Composite ") + typeid(T).name() +
                                             " constructor: Missing node for key '" + key + "'.");
                }
 
        // iterate node map pairs
        for (auto node_pair : _n)
        {
            // check that keys are char type
            char key;
            try
            {
                key = node_pair.first.as<char>();
            }
            catch (const std::exception& e)
            {
                throw std::runtime_error(std::string("In Composite ") + typeid(T).name() +
                                         " constructor: There is a key of type different than char: " +
                                         node_pair.first.as<std::string>() + ". Error: " + e.what());
            }
 
            // discard if not in _keys (if _keys is not ALL_KEYS)
            if (_keys != ALL_KEYS and                  //
                _keys.find(key) == std::string::npos)  //
                continue;
 
            // check field
            if (not _field.empty())
            {
                if (node_pair.second[_field])
                {
                    try
                    {
                        this->emplace(key, node_pair.second[_field].as<T>());
                    }
                    catch (const std::exception& e)
                    {
                        YAML::Emitter em;
                        em << node_pair.second[_field];
                        throw std::runtime_error("In Composite constructor: Failed to emplace the entry " + _field +
                                                 " for key '" + key + "' with error: " + e.what() + "\nNode:\n" +
                                                 em.c_str());
                    }
                }
                else if (_required)
                {
                    YAML::Emitter em;
                    em << node_pair.second;
                    throw std::runtime_error("In Composite constructor: Missing mandatory field '" + _field +
                                             "' for key '" + key + "'\nNode:\n" + em.c_str());
                }
            }
            else
            {
                try
                {
                    this->emplace(key, node_pair.second.as<T>());
                }
                catch (const std::exception& e)
                {
                    YAML::Emitter em;
                    em << node_pair.second;
                    throw std::runtime_error("In Composite constructor: Failed to emplace the entry for key '" +
                                             std::string(1, key) + "' with error: " + e.what() + "\nNode:\n" +
                                             em.c_str());
                }
            }
        }
    }
    else
    {
        WOLF_WARN("The YAML node is not defined. Constructing an empty composite");
    }
}
 
template <typename T>
inline bool Composite<T>::has(char _key) const
{
    return this->count(_key) != 0;
}
 
template <typename T>
inline bool Composite<T>::has(const StateKeys& _query_keys) const
{
    for (auto&& key : _query_keys)
    {
        if (not has(key))
        {
            return false;
        }
    }
    return true;
}
 
template <typename T>
inline StateKeys Composite<T>::getKeys() const
{
    StateKeys keys;
    for (auto&& pair : *this) keys.push_back(pair.first);
 
    return keys;
}
 
template <typename T>
inline Composite<T> Composite<T>::operator()(const std::string& _keys) const
{
    if (not this->has(_keys))
    {
        throw std::runtime_error("Composite<T>::operator() required keys " + _keys + " are not available, only have " +
                                 getKeys());
    }
 
    Composite<T> output;
    for (auto key : _keys)
    {
        output.emplace(key, this->at(key));
    }
    return output;
}
 
template <typename T>
inline YAML::Node Composite<T>::toYaml() const
{
    return YAML::Node(*this);
}
 
}  // namespace wolf
 
// CONVERSION TO YAML
namespace YAML
{
template <typename T>
struct convert<wolf::Composite<T>>
{
    static Node encode(const wolf::Composite<T>& composite)
    {
        Node n;
        for (auto&& pair : composite)
        {
            n[pair.first] = pair.second;
        }
 
        return n;
    }
 
    static bool decode(const Node& node, wolf::Composite<T>& composite)
    {
        composite = wolf::Composite<T>(node);
 
        return true;
    }
};
}  // namespace YAML